package com.shujia.base.day02


/**
 * scala中的集合有几种:
 *     1. List  元素能重复,且有索引,有序
 *     2. Set   元素唯一,且无序
 *     3. Map   元素是键值对的形式存储
 *     4. Tuple 固定元素个数,不可变
 */
object Demo17List {
  def main(args: Array[String]): Unit = {
    // 创建Scala中的List集合
    //    val list1: List[Nothing] = List() // 使用List()创建空的List集合
    val list2: List[Int] = List(11, 22, 33, 44, 11, 33, 55, 555, 66, 11, 22, 77, 88)
    println(list2)
    println("=" * 50)
    println("基础函数 [ take ]:")
    val resList1: List[Int] = list2.take(3) // 从左向右取出若干个元素,封装到新的集合中
    println(s"list2:${list2}")
    println(s"resList1:${resList1}")
    println("基础函数 [ takeRight ]:")
    val resList2: List[Int] = list2.takeRight(3) // 取出最右边三个,封装到新的集合中
    println(s"list2:${list2}")
    println(s"resList2:${resList2}")
    println("基础函数 [ reverse ]:")
    val resList3: List[Int] = list2.reverse // 反转,封装到新的集合中
    println(s"list2:${list2}")
    println(s"resList3:${resList3}")
    println("基础函数 [ distinct ]:")
    val resList4: List[Int] = list2.distinct // 对元素进行去重,封装到新的集合中
    println(s"list2:${list2}")
    println(s"resList4:${resList4}")
    println("基础函数 [ sum ]:")
    val number: Int = list2.sum // 当List集合中的元素是Int类型的时候,直接对所有元素加法运算
    println(s"list2:${list2}")
    println(s"number:${number}")
    println("基础函数 [ drop ]:")
    val resList5: List[Int] = list2.drop(3) // 从左向右删除若干个元素
    println(s"list2:${list2}")
    println(s"resList5:${resList5}")
    println("------")
    //    println("遍历List集合:")
    //    for(i<-list2){
    //      println(i)
    //    }
    //scala中的List集合也有索引
    //    println(list2(0))
    //    println(list2(1))
    //    println(list2(2))
    //    println(list2(3))
    //如果要去第一个元素的话,推荐使用函数获取
    println(list2.head)
    println(list2.last)
    println("基础函数 [ tail ]:")
    val resList6 = list2.tail // 去掉第一个元素,将剩下的元素封装到新的集合中
    println(s"list2:${list2}")
    println(s"resList6:${resList6}")
    println("基础函数 [ mkString ]:")
    val s1 = list2.mkString("_")
    println(s"list2:${list2}")
    println(s"s1:${s1}")

    println("=" * 50)
    println("进阶函数 [ map ]:")
    // 进一出一, 每一个元素都要执行一遍map函数逻辑,得到一个新的结果元素,类型可以发生变化
    val resList7: List[String] = list2.map((e: Int) => "数加: " + e)
    println(s"list2:${list2}")
    println(s"resList7:${resList7}")
    println("进阶函数 [ foreach ]:")
    //需求: 计算集合中所有偶数之和,奇数之和
    var ouSum = 0
    var jiSum = 0
    list2.foreach((e: Int) => {
      if (e % 2 == 0) {
        ouSum += e
      } else {
        jiSum += e
      }
    })
    println(s"list2:${list2}")
    println(s"偶数之和为:${ouSum}, 奇数之和为:${jiSum}")
    println("进阶函数 [ sortBy ]:") // 根据什么依据排序
    val resList8 = list2.sortBy((e: Int) => -e)
    println(s"list2:${list2}")
    println(s"resList8:${resList8}")
    //    val resList8 = list2.sortBy((e: Student) => s.score)
    println("进阶函数 [ sortWith ]:") // 元素两者之间的关系
    val resList9 = list2.sortWith((e1: Int, e2: Int) => e1 < e2)
    println(s"list2:${list2}")
    println(s"resList9:${resList9}")
    println("进阶函数 [ groupBy ]:")  //相同的元素为一组,得到map集合
    val map = list2.groupBy((e: Int) => e)
    println(map)
    println("进阶函数 [ flatMap ]:") // 类似于hivesql中的explode,扁平化
    val list3:List[String] = List("hello|world|flink", "hello|hadoop|flink", "spark|world|hello")
    val resList10 = list3.flatMap((e: String) => e.split("\\|"))
    println(s"list3:${list3}")
    println(s"resList10:${resList10}")
    println("进阶函数 [ filter ]:") // 过滤出符合条件的元素
    val resList11 = list2.filter((e:Int)=>e%22==0) // 传入的函数类型返回值是boolean,当结果是true的时候,该元素才会保留
    println(s"list32:${list2}")
    println(s"resList11:${resList11}")


    /**
     * 进阶函数:
     * map               对每一个元素单独进行处理，有返回值
     * foreach           对每一个元素单独进行处理，没有返回值
     * sortBy sortWith   根据条件排序
     * groupBy           将相同的元素分为一组【Map集合】元素是e->List(xx)
     * flatMap           扁平化
     * filter            跟据条件过滤出符合条件的元素
     */


  }
}
